{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algorithm DDPG\n",
    "****\n",
    "Randomly initialize critic network $Q(s,a|\\theta^Q)$ and actor $\\mu(s|\\theta^\\mu)$ with weights $\\theta^Q$ and $\\theta^\\mu$<br>\n",
    "initialize target network $Q'$ and $\\mu'$ with weights $\\theta^{Q'}\\leftarrow \\theta^Q, \\theta^{\\mu'} \\leftarrow \\theta^\\mu$<br>\n",
    "Initialize replay buffer $R$<br>\n",
    "**for** episode = 1, M **do**<br>\n",
    "&nbsp;&nbsp;&nbsp;Initialize a random process $N$ for action exploration<br>\n",
    "&nbsp;&nbsp;&nbsp;Receive initial observation state $s_1$<br>\n",
    "&nbsp;&nbsp;&nbsp;**for** t=1, T **do**<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Select action $a_t=\\mu(s_t|\\theta^\\mu)+N_t$ according to the current policy and exploration noise<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Excute action $a_t$ and observe reward $r_t$ and observe new state $s_{t+1}$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Store transition $(s_t,a_t,r_t,s_{t+1})$ in $R$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Sample a random minibatch of $N$ transitions $(s_i,a_i,r_i,s_{i+1})$ from $R$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Set $y_i=r_i+\\gamma Q'(s_{i+1},\\mu'(s_{i+1}|\\theta^{\\mu'})|\\theta^{Q'})$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Update critic by minimizing the loss: $L=\\frac{1}{N}\\sum_i(y_i-Q(s_i,a_i|\\theta^Q))^2$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Update the actor policy using the sampled policy gradient:\n",
    "$$\n",
    "\\nabla_{\\theta^\\mu}J\\approx\\frac{1}{N}\\sum_i\\nabla_aQ(s,a|\\theta^Q)|_{s=s_i,a=\\mu(s_i)}\\nabla_{\\theta^\\mu}\\mu(s|\\theta^\\mu)|s_i\n",
    "$$\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ubdate the target network:\n",
    "$$\n",
    "\\theta^{Q'}\\leftarrow \\tau \\theta^Q +(1-\\tau)\\theta^{Q'}\\\\\n",
    "\\theta^{\\mu'}\\leftarrow \\tau \\theta^\\mu+(1-\\tau)\\theta^{\\mu'}\n",
    "$$\n",
    "&nbsp;&nbsp;&nbsp;**end for**<br>\n",
    "**end for**<br>\n",
    "\n",
    "tips : $\\mu$ 表示确定策略<br>\n",
    "<br>\n",
    "### 代码表示Loss的计算:<br>\n",
    "* #### Critic Loss :\n",
    "$$\n",
    "\\frac{1}{N} \\sum_i \\overbrace{reward+(1.0-done) * gamma * target\\_value\\_net(next\\_state, target\\_policy\\_net(next\\_state))}^{target\\_value}- \\underbrace{value\\_net(state, action)}_{value}\n",
    "$$\n",
    "* #### Policy Loss :\n",
    "$$\n",
    "\\frac{1}{N} \\sum_i value\\_net(state, policy(state))\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 根据上边伪代码整理出以下表格:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><style type=\"text/css\">\n",
    ".tg  {border-collapse:collapse;border-spacing:0;border-color:#bbb;}\n",
    ".tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:0px;overflow:hidden;word-break:normal;border-top-width:1px;border-bottom-width:1px;border-color:#bbb;color:#594F4F;background-color:#E0FFEB;}\n",
    ".tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:0px;overflow:hidden;word-break:normal;border-top-width:1px;border-bottom-width:1px;border-color:#bbb;color:#493F3F;background-color:#9DE0AD;}\n",
    ".tg .tg-koh6{font-size:36px;border-color:inherit;text-align:left;vertical-align:top}\n",
    ".tg .tg-7ab7{font-weight:bold;font-size:36px;border-color:inherit;text-align:center;vertical-align:top}\n",
    ".tg .tg-bwtg{font-size:36px;border-color:inherit;text-align:center;vertical-align:top}\n",
    ".tg .tg-n9dp{background-color:#C2FFD6;font-size:36px;border-color:inherit;text-align:left;vertical-align:top}\n",
    "</style>\n",
    "<table class=\"tg\">\n",
    "  <tr>\n",
    "    <th class=\"tg-7ab7\">Algorithm</th>\n",
    "    <th class=\"tg-7ab7\">Neural Network</th>\n",
    "    <th class=\"tg-7ab7\">input</th>\n",
    "    <th class=\"tg-7ab7\">output</th>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-bwtg\" rowspan=\"2\">Critic</td>\n",
    "    <td class=\"tg-n9dp\">target critic network<br>θ^Q'</td>\n",
    "    <td class=\"tg-koh6\">next state s_{i+1} &amp;&amp;<br>the action a_{i+1} of s_{i+1} through θ^𝜇'</td>\n",
    "    <td class=\"tg-n9dp\">Q'(s_{i+1},a_{i+1})<br><big><big>for critic loss</big></big></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-n9dp\">critic network<br>θ^Q</td>\n",
    "    <td class=\"tg-koh6\">current state s_i &amp;&amp;<br>action in current state a_i</td>\n",
    "    <td class=\"tg-n9dp\">Q(s_i,a_i) <br><big><big>for critic loss and <br>policy loss</big></big></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-bwtg\" rowspan=\"2\">Actor</td>\n",
    "    <td class=\"tg-n9dp\">target actor network<br> θ^𝜇'</td>\n",
    "    <td class=\"tg-koh6\">next state s_{i+1}</td>\n",
    "      <td class=\"tg-n9dp\">action a_{i+1} at<br>state s_{i+1}<br><big><big>for critic loss</big></big></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-n9dp\">actor network <br>θ^𝜇</td>\n",
    "    <td class=\"tg-koh6\">current state s_i</td>\n",
    "    <td class=\"tg-n9dp\">𝜇(s_i)<br><big><big> for policy loss</big></big></td>\n",
    "  </tr>\n",
    "</table></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../assets/DDPG_landscape.png\" width=600 />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 特性总结\n",
    "1. 类似于DQN的replay buffer\n",
    "2. 类似于DQN的target network但此处更新的时候采用soft update\n",
    "3. 使用Actor_net输入s&&s'选择动作a&&a'分别用来更新actor_net和Q_net，使用Q_net输入a&&a'分别用来评估(s,a)和(s',a')来更新actor_net和Q_net\n",
    "4. 只能处理连续动作空间，离散动作不存在确定性策略的说法\n",
    "5. 标准化动作空间,对action 增加噪声\n",
    "6. actor-critic思想，但计算loss function的时候和A2C有很大不同<br>\n",
    "    a. A2C里的Critic loss $\\leftrightarrow$ TD error $\\leftrightarrow$ advantage function<br>\n",
    "    因为$\\hat{A}(s,a)=Q(s,a)-V(s)$是TD error的无偏估计。<br>\n",
    "    而DDPG里critic的计算和DoubleDQN很像，只不过计算target_Q的$a_{i+1}$是用网络$\\theta^{\\mu'}$所得的<br>\n",
    "    b.DDPG计算actor loss的时候估计是为了减少计算量，所以使用的是Q(s,a)而不是A(s,a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Tips:\n",
    "**np.clip $\\leftrightarrow$ torch.clamp <br>**\n",
    "$y_i = \\begin{cases}\n",
    "        \\text{min} & \\text{if } x_i < \\text{min} \\\\\n",
    "        x_i & \\text{if } \\text{min} \\leq x_i \\leq \\text{max} \\\\\n",
    "        \\text{max} & \\text{if } x_i > \\text{max}\n",
    "    \\end{cases}$<br>\n",
    "    <br>\n",
    "**torch.detach() , torch.data:<br>**\n",
    "都是将自动微分截断，也就是进行requires_grad=False操作<br>\n",
    "推荐使用detach()，可以对微分进行追踪<br>\n",
    "DDPG这里，将target_Q.detach()保证只更新value_net<br>\n",
    "<br>\n",
    "**Policy_net输出未加F.tanh()**<br>\n",
    "将动作空间控制在-1~+1哇完了<br>\n",
    "tanh公式为:<br>\n",
    "$\\text{Tanh}(x) = \\tanh(x) = \\frac{e^x - e^{-x}}{e^x + e^{-x}}$\n",
    "<img src=\"../assets/TanhReal.gif\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MountainCarContinuous-v0:感觉该环境可以考虑用HER解决<br>\n",
    "但是我加的噪声是相同的量，就会永远给小车一个向前或者向后的推力,但是这样操作。减少step的话就会没有效果<br>\n",
    "假设这个力是向前的(因为我们最终需要到达对面的山顶)，那么我就可以保持在推力的方向上施加一个向量<br>\n",
    "这个向量有什么作用呢?它可以让我永远是向着目标前进的，即使奖励值很稀疏。但我能sample出十分有用的信息<br>\n",
    "那么问题来了?我要怎么去求这个单位向量，或者说怎么去拟合这个单位向量。nn?<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "import gym\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.distributions import Normal\n",
    "# from torch.utils.tensorboard import SummaryWriter\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns; sns.set(color_codes=True)\n",
    "import pdb\n",
    "%matplotlib inline\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 经验回放\n",
    "class ReplayBuffer:\n",
    "    def __init__(self, column, batch_size, buffer_size):\n",
    "        self.current_state = np.zeros((buffer_size, column), dtype=np.float32)\n",
    "        self.next_state = np.zeros((buffer_size, column), dtype=np.float32)\n",
    "        init = lambda buffer_size : np.zeros(buffer_size, dtype=np.float32)\n",
    "        self.action = init(buffer_size)\n",
    "        self.reward = init(buffer_size)\n",
    "        self.done = init(buffer_size)\n",
    "        self.buffer_size, self.batch_size = buffer_size, batch_size\n",
    "        self.size, self.current_index = 0, 0\n",
    "    \n",
    "    def store(self, current_state, action, next_state, reward, done):\n",
    "        self.current_state[self.current_index] = current_state\n",
    "        self.action[self.current_index] = action\n",
    "        self.next_state[self.current_index] = next_state\n",
    "        self.reward[self.current_index] = reward\n",
    "        self.done[self.current_index] = done\n",
    "        self.current_index = (self.current_index + 1) % buffer_size\n",
    "        self.size = min(self.buffer_size, (self.size + 1))\n",
    "    \n",
    "    def sample(self):\n",
    "        index = np.random.choice(self.size, self.batch_size, replace=False)\n",
    "        return dict(current_state = torch.tensor(self.current_state[index],dtype=torch.float).to(device),\n",
    "                    action = torch.tensor(self.action[index]).reshape(-1, 1).to(device),\n",
    "                    next_state = torch.tensor(self.next_state[index],dtype=torch.float).to(device),\n",
    "                    reward = torch.tensor(self.reward[index]).reshape(-1, 1).to(device),\n",
    "                    done = torch.tensor(self.done[index]).reshape(-1, 1).to(device))\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wrapper 将输入数据进行预处理再输入到env中\n",
    "<img src=\"../assets/gym_wrapper.png\" align=center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "code_folding": [],
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# 对动作空间进行标准化(对输入(_action)输出(_reverse_action)到环境中的action进行标准化)。\n",
    "class NormalizeActions(gym.ActionWrapper):\n",
    "    \n",
    "    def __init__(self, env):\n",
    "        super(NormalizeActions, self).__init__(env)\n",
    "        self.low_bound = self.action_space.low # -2\n",
    "        self.upper_bound = self.action_space.high # +2\n",
    "        \n",
    "    def action(self, action):\n",
    "        # 神经网络使用 tanh 输出的动作在 -1 ~ +1 之间\n",
    "        action = self.low_bound + (action + 1.0) * 0.5 * (self.upper_bound - self.low_bound)\n",
    "        action = np.clip(action, self.low_bound, self.upper_bound)\n",
    "        \n",
    "        return action\n",
    "    \n",
    "    def reverse_action(self, action):\n",
    "        # 对 action 进行反转(reverse)，\n",
    "        action = 2 * (action - self.low_bound) / (self.upper_bound - self.low_bound) - 1\n",
    "        action = np.clip(action, self.low_bound, self.upper_bound)\n",
    "        \n",
    "        return actions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用确定性策略，对action增加噪声\n",
    "class OUNoise:\n",
    "    def __init__(self, action_space, mu=0.0, theta=0.15, max_sigma=0.3, min_sigma=0.1, decay_period=100000):\n",
    "        self.mu = mu\n",
    "        self.theta = theta\n",
    "        self.sigma = max_sigma\n",
    "        self.max_sigma = max_sigma\n",
    "        self.min_sigma = min_sigma\n",
    "        self.decay_period = decay_period\n",
    "        self.action_dim = action_space.shape[0]\n",
    "        self.low = action_space.low\n",
    "        self.high = action_space.high\n",
    "        # get 定义立即执行函数\n",
    "        self.reset()\n",
    "    \n",
    "    def reset(self):\n",
    "        self.state = np.ones(self.action_dim) * self.mu\n",
    "    \n",
    "    def evolve_state(self):\n",
    "        # self.state += [0.0] + 0.3 * np.random.randn(1)\n",
    "        self.state += self.theta * (self.mu - self.state)+np.random.randn(self.action_dim) # *np.sqrt(0.01) * self.sigma\n",
    "        return self.state\n",
    "    \n",
    "    def get_action(self, action, t=0):\n",
    "        # self.sigma = self.max_sigma\n",
    "        self.sigma = self.max_sigma - (self.max_sigma - self.min_sigma) * min(1.0, t / self.decay_period)\n",
    "        return np.clip(action + self.evolve_state(), self.low, self.high)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 两种方式，一种是先训练一层之后再cat。另一种是直接cat\n",
    "class ValueNetwork(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim):\n",
    "        super(ValueNetwork, self).__init__()\n",
    "        self.linear_state = nn.Linear(state_dim, 64)\n",
    "        self.linear_action = nn.Linear(action_dim, 64)\n",
    "        self.linear2 = nn.Linear(128, 32)\n",
    "        self.linear3 = nn.Linear(32, 1)\n",
    "    \n",
    "    def forward(self, state, action):\n",
    "        hidden_state = F.relu(self.linear_state(state))\n",
    "        hidden_action = F.relu(self.linear_action(action))\n",
    "        cat_state_action = torch.cat((hidden_action, hidden_state),dim=1)\n",
    "        hidden2 = F.relu(self.linear2(cat_state_action))\n",
    "        Q = self.linear3(hidden2)\n",
    "        return Q\n",
    "    \n",
    "#     def __init__(self, state_dim, action_dim):\n",
    "#         super(ValueNetwork, self).__init__()\n",
    "#         self.linear1 = nn.Linear(state_dim+action_dim, 256)\n",
    "#         self.linear2 = nn.Linear(256, 256)\n",
    "#         self.linear3 = nn.Linear(256, 1)\n",
    "    \n",
    "#     def forward(self, state, action):\n",
    "#         x = torch.cat((state, action),dim=1)\n",
    "#         x = F.relu(self.linear1(x))\n",
    "#         x = F.relu(self.linear2(x))\n",
    "#         Q = self.linear3(x)\n",
    "#         return Q\n",
    "\n",
    "class PolicyNetwork(nn.Module):\n",
    "    def __init__(self, in_dim, out_dim):\n",
    "        super(PolicyNetwork, self).__init__()\n",
    "        self.linear1 = nn.Linear(in_dim, 256)\n",
    "        self.linear2 = nn.Linear(256, 256)\n",
    "        self.linear3 = nn.Linear(256, out_dim) # (256, 1)\n",
    "    \n",
    "    def forward(self, state):\n",
    "        x = F.relu(self.linear1(state))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = torch.tanh(self.linear3(x))\n",
    "        return x\n",
    "    \n",
    "    def get_action(self, state):\n",
    "        state = torch.tensor(state,dtype=torch.float).unsqueeze(0).to(device)\n",
    "        action = self.forward(state)\n",
    "        return action.detach().cpu().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ddpg_train(batch_size, gamma=0.99, soft_tau=1e-2):\n",
    "    samples = replay_buffer.sample()\n",
    "    state, action, next_state = samples['current_state'], samples['action'], samples['next_state']\n",
    "    reward, done = samples['reward'], samples['done']\n",
    "    \n",
    "    target_value = reward + (1.0-done)*gamma*target_value_net(next_state, target_policy_net(next_state))\n",
    "    value = value_net(state, action)\n",
    "    value_loss = ((value - target_value.detach()).pow(2)).mean()\n",
    "    \n",
    "    policy_loss = -value_net(state, policy_net(state)).mean()\n",
    "    \n",
    "    value_optimizer.zero_grad()\n",
    "    value_loss.backward()\n",
    "    value_optimizer.step()\n",
    "    \n",
    "    policy_optimizer.zero_grad()\n",
    "    policy_loss.backward()\n",
    "    policy_optimizer.step()\n",
    "    \n",
    "    for target_param, param in zip(target_value_net.parameters(), value_net.parameters()):\n",
    "        target_param.data.copy_(target_param.data*(1.0-soft_tau) + param.data*soft_tau)\n",
    "    for target_param, param in zip(target_policy_net.parameters(), policy_net.parameters()):\n",
    "        target_param.data.copy_(target_param.data*(1.0-soft_tau) + param.data*soft_tau)\n",
    "    \n",
    "    return value_loss.item(), policy_loss.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# env = NormalizeActions(gym.make(\"Pendulum-v0\"))\n",
    "env = NormalizeActions(gym.make(\"MountainCarContinuous-v0\"))\n",
    "ou_noise = OUNoise(env.action_space)\n",
    "\n",
    "in_dim = env.observation_space.shape[0] # 3\n",
    "out_dim = env.action_space.shape[0] # 1 连续动作空间\n",
    "\n",
    "value_net = ValueNetwork(in_dim, out_dim).to(device)\n",
    "policy_net = PolicyNetwork(in_dim, out_dim).to(device)\n",
    "\n",
    "target_value_net = ValueNetwork(in_dim, out_dim).to(device)\n",
    "target_policy_net = PolicyNetwork(in_dim, out_dim).to(device)\n",
    "target_value_net.load_state_dict(value_net.state_dict())\n",
    "target_policy_net.load_state_dict(policy_net.state_dict())\n",
    "\n",
    "value_optimizer = optim.Adam(value_net.parameters())\n",
    "policy_optimizer = optim.Adam(policy_net.parameters(), lr=1e-4)\n",
    "\n",
    "buffer_size = 1000000\n",
    "batch_size = 128\n",
    "replay_buffer = ReplayBuffer(in_dim, batch_size, buffer_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "def smooth_plot(factor, item, plot_decay):\n",
    "    item_x = np.arange(len(item))\n",
    "    item_smooth = [np.mean(item[i:i+factor]) if i > factor else np.mean(item[0:i+1])\n",
    "                  for i in range(len(item))]\n",
    "    for i in range(len(item)// plot_decay):\n",
    "        item_x = item_x[::2]\n",
    "        item_smooth = item_smooth[::2]\n",
    "    return item_x, item_smooth\n",
    "    \n",
    "def plot(episode, rewards, value_losses, policy_losses):\n",
    "    clear_output(True)\n",
    "    rewards_x, rewards_smooth = smooth_plot(10, rewards, 500)\n",
    "    value_losses_x, value_losses_smooth = smooth_plot(10, value_losses, 30000)\n",
    "    policy_losses_x, policy_losses_smooth = smooth_plot(10, policy_losses, 30000)\n",
    "    \n",
    "    plt.figure(figsize=(18, 12))\n",
    "    plt.subplot(311)\n",
    "    plt.title('episode %s. reward: %s'%(episode, rewards_smooth[-1]))\n",
    "    plt.plot(rewards, label=\"Rewards\", color='lightsteelblue', linewidth='1')\n",
    "    plt.plot(rewards_x, rewards_smooth, label='Smothed_Rewards', color='darkorange', linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.subplot(312)\n",
    "    plt.title('Value_Losses')\n",
    "    plt.plot(value_losses,label=\"Value_Losses\",color='lightsteelblue',linewidth='1')\n",
    "    plt.plot(value_losses_x, value_losses_smooth, \n",
    "             label=\"Smoothed_Value_Losses\",color='darkorange',linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.subplot(313)\n",
    "    plt.title('Policy_Losses')\n",
    "    plt.plot(policy_losses,label=\"Policy_Losses\",color='lightsteelblue',linewidth='1')\n",
    "    plt.plot(policy_losses_x, policy_losses_smooth, \n",
    "             label=\"Smoothed_Policy_Losses\",color='darkorange',linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "code_folding": [],
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x864 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-4ba0dacdc993>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     15\u001b[0m         \u001b[0mreplay_buffer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maction\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnext_state\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreward\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreplay_buffer\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mbatch_size\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m             \u001b[0mvalue_loss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpolicy_loss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mddpg_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     18\u001b[0m             \u001b[0mvalue_losses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue_loss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m             \u001b[0mpolicy_losses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpolicy_loss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-6-be07af4bbc30>\u001b[0m in \u001b[0;36mddpg_train\u001b[0;34m(batch_size, gamma, soft_tau)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mddpg_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgamma\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.99\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msoft_tau\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1e-2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0msamples\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mreplay_buffer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maction\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnext_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'current_state'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'action'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'next_state'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mreward\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdone\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'reward'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'done'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-2-a60a1371554a>\u001b[0m in \u001b[0;36msample\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     26\u001b[0m                     \u001b[0mnext_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnext_state\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     27\u001b[0m                     \u001b[0mreward\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreward\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 28\u001b[0;31m                     done = torch.tensor(self.done[index]).reshape(-1, 1).to(device))\n\u001b[0m\u001b[1;32m     29\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     30\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__len__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "episodes = 3000\n",
    "# steps = 1000\n",
    "value_losses = []\n",
    "policy_losses = []\n",
    "all_rewards = []\n",
    "for episode in range(episodes):\n",
    "    state = env.reset()\n",
    "    ou_noise.reset()\n",
    "    episode_reward = 0\n",
    "    for step in range(steps):\n",
    "        action = policy_net.get_action(state)\n",
    "        action = ou_noise.get_action(action, step)\n",
    "        next_state, reward, done, _ = env.step(action.flatten())\n",
    "        \n",
    "        replay_buffer.store(state, action, next_state.flatten(), reward, done)\n",
    "        if len(replay_buffer) > batch_size :\n",
    "            value_loss, policy_loss = ddpg_train(batch_size)\n",
    "            value_losses.append(value_loss)\n",
    "            policy_losses.append(policy_loss)\n",
    "        \n",
    "        state = next_state\n",
    "        episode_reward += reward\n",
    "        \n",
    "        if done:\n",
    "            break\n",
    "    \n",
    "#     soft_loss = lambda loss : np.mean(loss[-100:]) if len(loss)>=100 else np.mean(loss)\n",
    "#     writer.add_scalar(\"Reward\", episode_reward, episode)\n",
    "#     writer.add_scalar(\"Value_Losses\", soft_loss(value_losses), episode)\n",
    "#     writer.add_scalar(\"Policy_Losses\", soft_loss(policy_losses), episode)\n",
    "    \n",
    "    all_rewards.append(episode_reward)\n",
    "    \n",
    "    plot(episode, all_rewards, value_losses, policy_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# torch.save(policy_net.state_dict(), \"./model/DDPG.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# policy_net_1 = PolicyNetwork(in_dim, out_dim)\n",
    "# policy_net_1.load_state_dict(torch.load(\"./model/DDPG.pth\"))\n",
    "# policy_net_1.eval()\n",
    "\n",
    "import pdb\n",
    "import gym\n",
    "from IPython import display\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "env = gym.make(\"MountainCarContinuous-v0\")\n",
    "state = env.reset()\n",
    "img = plt.imshow(env.render(mode='rgb_array')) # only call this once\n",
    "for _ in range(1000):\n",
    "    img.set_data(env.render(mode='rgb_array')) # just update the data\n",
    "    display.display(plt.gcf())\n",
    "    display.clear_output(wait=True)\n",
    "    policy_net = policy_net.cpu()\n",
    "    \n",
    "    action = policy_net(torch.FloatTensor(state)).detach().numpy()\n",
    "    # action = env.action_space.sample()\n",
    "    next_state, _, done, _ = env.step(action)\n",
    "    if done: \n",
    "        state = env.reset()\n",
    "    state = next_state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**发现训练了大概有12个小时还没完，是我的episode设置太多了，从tensorboard的图中看出大概1个小时就训练收敛了<br>\n",
    "中途停了，所以最后没有画出图来，还好tensorboard有记录**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* #### 初次训练的图:\n",
    "<img src=\"../assets/ddpg_first_train.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* #### 未加tanh的训练图:<br>\n",
    "**Reward :**\n",
    "<img src=\"../assets/Reward.png\"><br>\n",
    "**Value_Losses :**\n",
    "<img src=\"../assets/Value_Losses.png\"><br>\n",
    "**Policy_Losses :**\n",
    "<img src=\"../assets/Policy_Losses.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* #### 有加tanh的训练图:<br>\n",
    "**Reward :**\n",
    "<img src=\"../assets/Reward_with_tanh.png\"><br>\n",
    "**Value_Losses :**\n",
    "<img src=\"../assets/Value_Losses_with_tanh.png\"><br>\n",
    "**Policy_Losses :**\n",
    "<img src=\"../assets/Policy_Losses_with_tanh.png\">"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "oldHeight": 691.0904539999999,
   "position": {
    "height": "712.537px",
    "left": "682.088px",
    "right": "20px",
    "top": "253px",
    "width": "603.05px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "varInspector_section_display": "block",
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
